home *** CD-ROM | disk | FTP | other *** search
/ Best of Shareware / Best of PC Windows Shareware 1.0 - Wayzata Technology (7111) (1993).iso / mac / ZIPPED / DOS / GRAPHICS / POVSRC.ZIP / MACHINE.ZIP / UNIX.ZIP / XWINDOWS.C < prev    next >
C/C++ Source or Header  |  1992-03-18  |  17KB  |  619 lines
  1. /****************************************************************************
  2. *                xwindows.c
  3. *
  4. *  This module implements X-windows specific routines.
  5. *
  6. *  from Persistence of Vision Raytracer 
  7. *  Copyright 1991 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  Copying, distribution and legal info is in the file povlegal.doc which
  10. *  should be distributed with this file. If povlegal.doc is not available
  11. *  or for more info please contact:
  12. *
  13. *       Drew Wells [POV-Team Leader] 
  14. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  15. *       Phone: (213) 254-4041
  16. * 
  17. * This program is based on the popular DKB raytracer version 2.12.
  18. * DKBTrace was originally written by David K. Buck.
  19. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  20. *
  21. *****************************************************************************/
  22.  
  23.  /*
  24.  * Here are some routines I wrote which implement +d option on unix computers
  25.  * running X-windows. For now, only black and white output is supported. If I
  26.  * get access to a computer with a color monitor, I'll probably add support
  27.  * for colors to my routines.
  28.  * 
  29.  * In future I'll probably add some more dithering methods. I have tested these
  30.  * routines on SUN 3 and SUN 4. I'm using the tvtwm window manager.
  31.  * 
  32.  * If you have some suggestions to my source code or if you change anything,
  33.  * please let me know. I can be reached at the following address: Marek
  34.  * Rzewuski, Avstikkeren 11, 1156 Oslo 11, Norway or marekr@ifi.uio.no on
  35.  * Internet.
  36.  */
  37.  
  38. /*
  39.  * 91-07-29 Allan H. Wax (Wax.OSBU_South@Xerox.COM) Hacked this module so it
  40.  * can be used with either a colour or B&W screen. Made all variables local
  41.  * to this routine (no need for more globals if no one ever uses them). Fixed
  42.  * bug in refresh routine. Use dither from colorx.c. Use xpov.icon instead of
  43.  * theIcon.
  44.  */
  45.  
  46. #include <stdio.h>
  47. #include <X11/Xlib.h>        /* some Xlib stuff */
  48. #include <X11/Xutil.h>
  49. #include <X11/Xos.h>
  50. #include <X11/Xatom.h>
  51. #include "xpov.icn"
  52. #include <math.h>
  53.  
  54. #include "frame.h"
  55. #include "povproto.h"
  56.  
  57. #define     BORDER_WIDTH    2
  58. #define    EV_MASK    (ButtonPressMask | \
  59.          KeyPressMask     | \
  60.          ExposureMask    | \
  61.          StructureNotifyMask)
  62.  
  63. static Display *theDisplay;
  64. static int      theScreen;
  65. static int      theDepth;
  66. static unsigned long theBlackPixel;
  67. static unsigned long theWhitePixel;
  68. static XEvent   theEvent;
  69. static Window   theWindow, openWindow();
  70. static GC       theGC;
  71. static unsigned char *bitmap;    /* pointer to our picture bitmap */
  72. static unsigned char *bitmapPos;/* position to the last drawn pixel in our
  73.                  * bitmap */
  74.  
  75.  
  76. static char    *display_name = 0;
  77. static int     disp_wide, disp_high;
  78. static XImage  *xi;
  79. static char    *data;
  80. static XGCValues gcvalues;
  81. static long     colorpixels[256];
  82. static Bool     iscolor;
  83. static int     screen_open = 0;
  84.  
  85. struct {
  86.     void            (*Init) ();
  87.     void            (*Close) ();
  88.     void            (*Finished) ();
  89.     void            (*Plot) ();
  90. }               display;
  91.  
  92. /* global POVRay variables */
  93.  
  94. extern FRAME    Frame;
  95. extern unsigned int Options;
  96. extern char     DisplayFormat;
  97. extern int      First_Line;
  98.  
  99. /*
  100.  * Sets up a connection to the X server and stores informations about the
  101.  * enviroment
  102.  */
  103.  
  104. static          initX()
  105. {
  106.     theDisplay = XOpenDisplay(NULL);
  107.     if (theDisplay == NULL) {
  108.     fprintf(stderr, "ERROR: Cannot establish a connection to the X server %s\n",
  109.         XDisplayName(NULL));
  110.     exit(1);
  111.     }
  112.     theScreen = DefaultScreen(theDisplay);
  113.     theDepth = DefaultDepth(theDisplay, theScreen);
  114.     theWhitePixel = WhitePixel(theDisplay, theScreen);
  115.     theBlackPixel = BlackPixel(theDisplay, theScreen);
  116. }
  117.  
  118. /*
  119.  * This procedure will do the following things: 1)     Set up attributes
  120.  * desired for the window 2)    Set up an icon to our window. 3)     Send
  121.  * hints to the window manager. 4)     Open a window on the display 5)    Tell
  122.  * the X to place the window on the screen 6)    Flush out all the queued up X
  123.  * requests to the X server
  124.  */
  125.  
  126. static Window   openWindow(x, y, width, height, flag, theNewGC)
  127. int             x, y;
  128. int             width, height;
  129. int             flag;
  130. GC             *theNewGC;
  131. {
  132.     XSetWindowAttributes theWindowAttributes;
  133.     XSizeHints      theSizeHints;
  134.     unsigned long   theWindowMask;
  135.     Window          theNewWindow;
  136.     Pixmap          theIconPixmap;
  137.     XWMHints        theWMHints;
  138.  
  139.  
  140.     /*
  141.      * Set up some attributes for the window. Override_redirect tells the
  142.      * window manager to deal width the window or leave it alone
  143.      */
  144.  
  145.     theWindowAttributes.border_pixel = theBlackPixel;
  146.     theWindowAttributes.background_pixel = theWhitePixel;
  147.     theWindowAttributes.override_redirect = False;
  148.     theWindowMask = CWBackPixel | CWBorderPixel | CWOverrideRedirect;
  149.  
  150.     /* Now, open out window */
  151.  
  152.     theNewWindow = XCreateWindow(theDisplay,
  153.                  RootWindow(theDisplay, theScreen),
  154.                  x, y,
  155.                  width, height,
  156.                  BORDER_WIDTH,
  157.                  theDepth,
  158.                  InputOutput,
  159.                  CopyFromParent,
  160.                  theWindowMask,
  161.                  &theWindowAttributes);
  162.  
  163.     /* Create one iconbitmap */
  164.  
  165.     theIconPixmap = XCreateBitmapFromData(theDisplay,
  166.                       theNewWindow,
  167.                       xpov_bits,
  168.                       xpov_width,
  169.                       xpov_height);
  170.  
  171.     /*
  172.      * Now tell the window manager where on screen we should place our
  173.      * window.
  174.      */
  175.  
  176.     theWMHints.icon_pixmap = theIconPixmap;
  177.     theWMHints.initial_state = NormalState;    /* we don't want an iconized
  178.                          * window when it's created */
  179.     theWMHints.flags = IconPixmapHint | StateHint;
  180.  
  181.     XSetWMHints(theDisplay, theNewWindow, &theWMHints);
  182.  
  183.     theSizeHints.flags = PPosition | PSize;
  184.     theSizeHints.x = x;
  185.     theSizeHints.y = y;
  186.     theSizeHints.width = width;
  187.     theSizeHints.height = height;
  188.     /*
  189.      * theSizeHints.min_width    = width; theSizeHints.min_height    =
  190.      * height; theSizeHints.max_width    = width; theSizeHints.max_height =
  191.      * height;
  192.      */
  193.  
  194.     XSetNormalHints(theDisplay, theNewWindow, &theSizeHints);
  195.  
  196.  
  197.     if (createGC(theNewWindow, theNewGC) == 0) {
  198.     XDestroyWindow(theDisplay, theNewWindow);
  199.     return ((Window) 0);
  200.     }
  201.  
  202.     /* make a name for our window */
  203.  
  204.     XStoreName(theDisplay, theNewWindow, "POVRay \0");
  205.  
  206.     /*
  207.      * Now, could we please see the window on the screen? Until now, we have
  208.      * dealed with a window which has been created but noe appeared on the
  209.      * screen. Maping the window places it visibly    on the screen
  210.      */
  211.  
  212.     XMapWindow(theDisplay, theNewWindow);
  213.     XFlush(theDisplay);
  214.     return (theNewWindow);
  215. }
  216.  
  217. static          refreshWindow(theExposedWindow)
  218. Window          theExposedWindow;
  219. {
  220.     int             i = 0, x = 0, y = First_Line;
  221.     register unsigned char *dummy = bitmap;
  222.     while (dummy != bitmapPos) {
  223.     /* draw until most current pixel is drawn */
  224.     if (*dummy)
  225.         XDrawPoint(theDisplay, theWindow, theGC, x, y);
  226.     if (x == Frame.Screen_Width) {
  227.         x = 0;
  228.         y++;
  229.     }
  230.     else {
  231.         dummy++;
  232.         x++;
  233.         i++;
  234.     }
  235.     }
  236.     XFlush(theDisplay);
  237. }
  238.  
  239. /* Creates a new graphics context */
  240.  
  241. static int      createGC(theNewWindow, theNewGC)
  242. Window          theNewWindow;
  243. GC             *theNewGC;
  244. {
  245.     XGCValues       theGCValues;
  246.     *theNewGC = XCreateGC(theDisplay,
  247.               theNewWindow,
  248.               (unsigned long) 0,
  249.               &theGCValues);
  250.  
  251.     if (*theNewGC == 0) {
  252.     return (0);        /* error */
  253.     }
  254.     else {            /* set foreground and background defaults for
  255.                  * the new GC */
  256.     XSetForeground(theDisplay,
  257.                *theNewGC,
  258.                theBlackPixel);
  259.  
  260.     XSetBackground(theDisplay,
  261.                *theNewGC,
  262.                theWhitePixel);
  263.  
  264.     return (1);        /* OK */
  265.     }
  266. }
  267.  
  268. static          initEvents(theWindow)
  269. Window          theWindow;
  270. {
  271.     XSelectInput(theDisplay,
  272.          theWindow,
  273.          EV_MASK);
  274. }
  275.  
  276. void            BWFinished()
  277. {
  278.  
  279. }
  280.  
  281.  
  282. void            BWInit()
  283. {
  284.     int             i;
  285.  
  286.     /*
  287.      * set some room for a bitmap for our picture. I've got to "remember" the
  288.      * whole picture bacuse of resizing of the window, overlapping etc. Then
  289.      * I've got to refresh the picture. This should be easy to convert to an
  290.      * "color version" in future
  291.      */
  292.  
  293.     bitmap = (unsigned char *) malloc(sizeof(unsigned char) *
  294.                 (Frame.Screen_Width * Frame.Screen_Height));
  295.     bitmapPos = bitmap;
  296.     if (bitmap == NULL)
  297.     printf("ERROR: Can not allocate the buffer..\n");
  298.  
  299.     for (i = 0; i < (Frame.Screen_Width * Frame.Screen_Height); i++) {
  300.     *bitmapPos++ = 0;
  301.     }
  302.     bitmapPos = bitmap;
  303.     initX();
  304.     theWindow = openWindow(0, 0, Frame.Screen_Width, Frame.Screen_Height, 0, &theGC);
  305.     initEvents(theWindow);
  306.     XFlush(theDisplay);
  307.     XNextEvent(theDisplay, &theEvent);
  308.     XFlush(theDisplay);
  309. }                /* end of display initilazation */
  310.  
  311. void            BWClose()
  312. {
  313.     sleep(10);            /* an simple delay. 10 seconds. */
  314.     XDestroyWindow(theDisplay, theWindow);
  315.     XFlush(theDisplay);
  316.     XCloseDisplay(theDisplay);
  317.     free(bitmap);
  318. }
  319.  
  320. void            BWPlot(x, y, Red, Green, Blue)
  321. int             x, y;
  322. unsigned char   Red, Green, Blue;
  323. {
  324.     unsigned char   color;
  325.     long            thePixel;
  326.     /* lets find if there are some events waiting for us */
  327.  
  328.     while (XPending(theDisplay) > 0) {    /* now deal with the events.. */
  329.     XNextEvent(theDisplay, &theEvent);
  330.  
  331.     switch (theEvent.type) {
  332.       case Expose:
  333.         /* printf("Window is exposed.\n"); */
  334.         refreshWindow(theEvent.xany.window);
  335.         break;
  336.  
  337.       case MapNotify:
  338.         /* printf("The window is mapped.\n"); */
  339.         refreshWindow(theEvent.xany.window);
  340.         break;
  341.  
  342.       case ButtonPress:
  343.         /* printf("A mouse button was pressed.\n"); */
  344.         break;
  345.  
  346.       case ConfigureNotify:
  347.         /* printf("The window configuration has been changed\n"); */
  348.         refreshWindow(theEvent.xany.window);
  349.         break;
  350.     }
  351.     }
  352.     if (dither(x, y, Red, Green, Blue)) {
  353.     thePixel = BlackPixel(theDisplay, theScreen);
  354.     XDrawPoint(theDisplay, theWindow, theGC, x, y);
  355.     XFlush(theDisplay);
  356.     }
  357.     else {
  358.     thePixel = WhitePixel(theDisplay, theScreen);
  359.     }
  360.     *bitmapPos++ = thePixel;
  361. }
  362.  
  363. /* so we can get at the dimensions */
  364. extern FRAME    Frame;
  365.  
  366. /* x11 stuff */
  367.  
  368. static Bool     evtPred(d, e, a)
  369. Display        *d;
  370. XEvent         *e;
  371. char           *a;
  372. {
  373.     return (True);
  374. }
  375.  
  376. static void     BuildColormap()
  377. {
  378.     XColor          tmp;
  379.     register unsigned short r, g, b, i;
  380.     Colormap        cmap;
  381.  
  382.     /*
  383.      * build a colormap that will contain 216, or 6^3 colors. We won't do
  384.      * anything clever like adding extra grays in the leftover space.
  385.      * Remember, this was written in a few hours.
  386.      */
  387.     cmap = DefaultColormap(theDisplay, theScreen);
  388.  
  389.     i = 0;
  390.     for (r = 0; r < 6; r++) {
  391.     for (g = 0; g < 6; g++) {
  392.         for (b = 0; b < 6; b++, i++) {
  393.         tmp.red = (r * 36) << 8;
  394.         tmp.green = (g * 36) << 8;
  395.         tmp.blue = (b * 36) << 8;
  396.         tmp.flags = DoRed | DoGreen | DoBlue;
  397.         if (!XAllocColor(theDisplay, cmap, &tmp))
  398.             goto crap_out;
  399.         colorpixels[i] = tmp.pixel;
  400.         }
  401.     }
  402.     }
  403. crap_out:            /* couldn't get what we wanted.  Boo-hoo. */
  404.     if (i != 216)
  405.     fprintf(stderr, "warning: could only get %d colors.\n", i);
  406. }
  407.  
  408. void            ColourFinished()
  409. {
  410.     XEvent         *report;
  411.     /* do nothing.  I suppose we could wait... */
  412.     while (1) {
  413.     XNextEvent(theDisplay, &report);
  414.     XPutImage(theDisplay, theWindow, theGC, xi, 0, 0, 0, 0, Frame.Screen_Width,
  415.           Frame.Screen_Height);
  416.     }
  417. }
  418.  
  419. void            display_close()
  420. {
  421.     if(screen_open)
  422.             (display.Close) ();
  423. }
  424.  
  425. void            display_plot(x, y, Red, Green, Blue)
  426. int             x, y;
  427. unsigned char   Red, Green, Blue;
  428. {
  429.     (display.Plot) (x, y, Red, Green, Blue);
  430. }
  431.  
  432. void            display_finished()
  433. {
  434.     if(screen_open)
  435.             (display.Finished) ();
  436. }
  437.  
  438. void            ColourInit()
  439. {
  440.     Pixmap          icon;
  441.     XSizeHints      hints;
  442.     long            size, i;
  443.     XSetWindowAttributes attrib;
  444.  
  445.     if ((theDisplay = XOpenDisplay(display_name)) == NULL) {
  446.     fprintf(stderr, "Can't open X server %s.\n",
  447.         XDisplayName(display_name));
  448.     exit(1);
  449.     }
  450.     theScreen = DefaultScreen(theDisplay);
  451.  
  452.     /* screen dimensions */
  453.     disp_wide = DisplayWidth(theDisplay, theScreen);
  454.     disp_high = DisplayHeight(theDisplay, theScreen);
  455.  
  456.     theWindow = XCreateSimpleWindow(theDisplay, RootWindow(theDisplay, theScreen),
  457.                   (disp_wide - Frame.Screen_Width) / 2,
  458.                   (disp_high - Frame.Screen_Height) / 2,
  459.                   Frame.Screen_Width,
  460.                   Frame.Screen_Height, 2 /* border width */ ,
  461.               BlackPixel(theDisplay, theScreen), WhitePixel(theDisplay, theScreen));
  462.  
  463.     /* create a graphics context for drawing */
  464.     gcvalues.function = GXcopy;
  465.     theGC = XCreateGC(theDisplay, theWindow, GCFunction, &gcvalues);
  466.  
  467.     /* make a cute icon */
  468.     icon = XCreateBitmapFromData(theDisplay, theWindow, xpov_bits, xpov_width,
  469.                  xpov_height);
  470.  
  471.     /* give a few clues about ourself */
  472.     hints.flags = PPosition | PSize | PMinSize;
  473.     hints.x = (disp_wide - Frame.Screen_Width) / 2;
  474.     hints.y = (disp_high - Frame.Screen_Height) / 2;
  475.     hints.width = Frame.Screen_Width;
  476.     hints.height = Frame.Screen_Height;
  477.     hints.min_width = 32;
  478.     hints.min_height = 32;
  479.  
  480.     XSetStandardProperties(theDisplay, theWindow, "povray", "povray", icon, NULL, 0,
  481.                &hints);
  482.  
  483.     /* only want to know about expose events */
  484.     XSelectInput(theDisplay, theWindow, ExposureMask);
  485.     XMapWindow(theDisplay, theWindow);
  486.  
  487.     BuildColormap();
  488.  
  489.     size = Frame.Screen_Width * Frame.Screen_Height;
  490.     data = (char *) XtMalloc(size);
  491.     for (i = 0; i < size; i++)
  492.     data[i] = 0;
  493.     xi = XCreateImage(theDisplay, DefaultVisual(theDisplay, theScreen), 8, ZPixmap, 0, data,
  494.         Frame.Screen_Width, Frame.Screen_Height, 8, Frame.Screen_Width);
  495. };
  496.  
  497. void            ColourClose()
  498. {
  499.     sleep(10);
  500.     XDestroyImage(xi);
  501.     XtFree(data);
  502.     XDestroyWindow(theDisplay, theWindow);
  503.     XCloseDisplay(theDisplay);
  504. }
  505.  
  506.  /* static */ int dither(x, y, Red, Green, Blue)
  507. register unsigned int x, y;
  508. unsigned char   Red, Green, Blue;
  509. {
  510.     /*
  511.      * Perform ordered dithering for halftone screen. For details, see
  512.      * Graphics Gems, Ed. Andrew Glassner, p. 176-178 Floyd-Steinberg dither
  513.      * would look better, but we would need more saved state, making the
  514.      * coding a lot uglier.  Since this is just a display hack and not an
  515.      * image processing package, I don't bother.
  516.      */
  517.     static unsigned int dm[] = {
  518.     0, 192, 48, 240, 12, 204, 60, 252,
  519.     128, 64, 176, 112, 140, 76, 188, 124,
  520.     32, 224, 16, 208, 44, 236, 28, 220,
  521.     160, 96, 144, 80, 172, 108, 156, 92,
  522.     8, 200, 56, 248, 4, 196, 52, 244,
  523.     136, 72, 184, 120, 132, 68, 180, 116,
  524.     40, 232, 24, 216, 36, 228, 20, 212,
  525.     168, 104, 152, 88, 164, 100, 148, 84
  526.     };
  527.     register unsigned long luminence =
  528.     (307 * Red + 599 * Green + 118 * Blue) / 1024;
  529.     return (luminence < dm[(x & 7) + ((y & 7) << 3)]);
  530. }
  531.  
  532. void            ColourPlot(x, y, Red, Green, Blue)
  533. int             x, y;
  534. unsigned char   Red, Green, Blue;
  535. {
  536.     long            thePixel;
  537.     int             r, g, b;
  538.     XEvent          report;
  539.     int             luminence;
  540.  
  541.     /* scale rgb to be in our 216 color space */
  542.     r = (Red * 216) / (256 * 36);
  543.     g = (Green * 216) / (256 * 36);
  544.     b = (Blue * 216) / (256 * 36);
  545.  
  546.     /* find the pixel we got */
  547.     thePixel = colorpixels[(r * 36) + (g * 6) + b];
  548.     XPutPixel(xi, x, y, thePixel);
  549.     /* on each pixel, copy a scanline.  Inefficient, but so what?  See above. */
  550.     XPutImage(theDisplay, theWindow, theGC, xi, 0, y, 0, y, Frame.Screen_Width, 1);
  551.  
  552.     /* poll for exposure events */
  553.     if (XCheckIfEvent(theDisplay, &report, evtPred, "blah")) {
  554.     XPutImage(theDisplay, theWindow, theGC, xi, 0, 0, 0, 0, Frame.Screen_Width, y + 1);
  555.     }
  556. }
  557.  
  558. void unix_init_POVRAY PARAMS((void))
  559. {
  560. }
  561.  
  562. int             matherr(x)
  563. struct exception *x;
  564. {
  565.     switch (x->type) {
  566.       case DOMAIN:
  567.       case OVERFLOW:
  568.     x->retval = 1.0e17;
  569.     break;
  570.  
  571.       case SING:
  572.       case UNDERFLOW:
  573.     x->retval = 0.0;
  574.     break;
  575.  
  576.       default:
  577.     break;
  578.     }
  579.     return (1);
  580. }
  581.  
  582. extern void     BWInit(), BWClose(), BWFinished(), BWPlot();
  583.  
  584. void            display_init()
  585. {
  586.     Pixmap          icon;
  587.     XSizeHints      hints;
  588.     long            size, i;
  589.     XSetWindowAttributes attrib;
  590.  
  591.     if ((theDisplay = XOpenDisplay(display_name)) == NULL) {
  592.     fprintf(stderr, "Can't open X server %s.\n",
  593.         XDisplayName(display_name));
  594.     exit(1);
  595.     }
  596.     
  597.     screen_open = 1;
  598.     
  599.     theScreen = DefaultScreen(theDisplay);
  600.     iscolor = (XDisplayCells(theDisplay, theScreen) > 2);
  601.  
  602.     if (iscolor) {
  603.     display.Init = ColourInit;
  604.     display.Close = ColourClose;
  605.     display.Finished = ColourFinished;
  606.     display.Plot = ColourPlot;
  607.     }
  608.     else {
  609.     display.Init = BWInit;
  610.     display.Close = BWClose;
  611.     display.Finished = BWFinished;
  612.     display.Plot = BWPlot;
  613.     }
  614.  
  615.     XCloseDisplay(theDisplay);
  616.     (display.Init) ();
  617.  
  618. }
  619.